import * as THREE from 'three';
import { CameraController } from '../CameraController.js';
import { ScaleGrid } from '../ScaleGrid.js';

// 场景基类 - 所有场景都继承此类
export class BaseScene {
    constructor(name) {
        this.name = name;
        this.scene = new THREE.Scene();
        this.camera = null;
        this.cameraController = null; // 统一的相机控制器
        this.scaleGrid = null; // 比例尺网格
        this.objects = []; // 存储场景中的对象，方便管理
        this.lights = [];
        this.isActive = false;
        this.mode = 'edit'; // 'edit' 或 'presentation'
    }

    // 初始化场景 - 子类必须实现
    init() {
        throw new Error('子类必须实现 init() 方法');
    }

    /**
     * 设置相机控制器（统一的平移、旋转、缩放功能）
     * 子类在创建相机后应该调用此方法
     * @param {WebGLRenderer} renderer - Three.js 渲染器
     * @param {Object} options - 可选配置参数
     */
    setupCameraController(renderer, options = {}) {
        if (!this.camera) {
            console.warn('⚠️ 请先创建相机再设置相机控制器');
            return;
        }

        // 创建相机控制器
        this.cameraController = new CameraController(this.camera, renderer.domElement);
        
        // 应用配置
        if (options.target) {
            this.cameraController.setTarget(
                options.target.x || 0,
                options.target.y || 0,
                options.target.z || 0
            );
        } else {
            this.cameraController.setTarget(0, 0, 0);
        }
        
        if (options.minDistance !== undefined) {
            this.cameraController.minDistance = options.minDistance;
        }
        
        if (options.maxDistance !== undefined) {
            this.cameraController.maxDistance = options.maxDistance;
        }
        
        if (options.rotateSpeed !== undefined) {
            this.cameraController.rotateSpeed = options.rotateSpeed;
        }
        
        if (options.panSpeed !== undefined) {
            this.cameraController.panSpeed = options.panSpeed;
        }
        
        if (options.zoomSpeed !== undefined) {
            this.cameraController.zoomSpeed = options.zoomSpeed;
        }
        
        console.log(`📷 场景 "${this.name}" 的相机控制器已启用`);
    }

    // 更新场景 - 每帧调用（可选）
    update(deltaTime) {
        // 更新相机控制器
        if (this.cameraController) {
            this.cameraController.update();
        }
        
        // 更新屏幕比例尺（实时显示当前视野的尺度）
        if (this.scaleGrid && this.camera) {
            this.scaleGrid.updateScreenScale();
        }
        
        // 子类可以重写此方法实现动画逻辑
        // 但要记得调用 super.update(deltaTime) 以保持相机控制器更新
    }

    /**
     * 初始化比例尺
     * @param {number} gridSize - 网格大小（米）
     */
    setupScaleGrid(gridSize = 50) {
        if (!this.scaleGrid) {
            this.scaleGrid = new ScaleGrid();
            if (gridSize !== 50) {
                this.scaleGrid.updateGridSize(gridSize);
            }
            this.scaleGrid.addToScene(this.scene);
            
            // 关联相机（用于屏幕比例尺计算）
            if (this.camera) {
                this.scaleGrid.setCamera(this.camera);
            }
            
            // 根据当前模式显示/隐藏比例尺
            if (this.mode === 'presentation') {
                this.scaleGrid.hide();
            } else {
                this.scaleGrid.show();
            }
            
            console.log(`📏 场景 "${this.name}" 的比例尺已启用`);
        }
    }

    /**
     * 设置场景模式
     * @param {string} mode - 'edit' 或 'presentation'
     */
    setMode(mode) {
        this.mode = mode;
        
        // 根据模式控制比例尺显示
        if (this.scaleGrid) {
            if (mode === 'presentation') {
                this.scaleGrid.hide();
            } else {
                this.scaleGrid.show();
            }
        }
        
        console.log(`🎨 场景 "${this.name}" 模式已设置为: ${mode}`);
    }

    /**
     * 切换比例尺显示
     */
    toggleScaleGrid() {
        if (this.scaleGrid) {
            this.scaleGrid.toggle();
        }
    }

    // 激活场景
    activate() {
        this.isActive = true;
        console.log(`✅ 场景 "${this.name}" 已激活`);
    }

    // 停用场景
    deactivate() {
        this.isActive = false;
        console.log(`⏸️ 场景 "${this.name}" 已停用`);
    }

    // 清理场景资源
    dispose() {
        // 清理相机控制器
        if (this.cameraController) {
            this.cameraController.dispose();
            this.cameraController = null;
        }
        
        // 清理比例尺
        if (this.scaleGrid) {
            this.scaleGrid.dispose();
            this.scaleGrid = null;
        }
        
        // 清理几何体和材质
        this.objects.forEach(obj => {
            if (obj.geometry) obj.geometry.dispose();
            if (obj.material) {
                if (Array.isArray(obj.material)) {
                    obj.material.forEach(mat => mat.dispose());
                } else {
                    obj.material.dispose();
                }
            }
        });
        
        // 清空场景
        while(this.scene.children.length > 0) {
            this.scene.remove(this.scene.children[0]);
        }
        
        console.log(`🗑️ 场景 "${this.name}" 资源已清理`);
    }

    // 获取场景对象
    getScene() {
        return this.scene;
    }

    // 获取相机
    getCamera() {
        return this.camera;
    }
}

